Integratsion Testlash: Supertest yordamida API Testlashni O'zlashtirish

Dasturiy ta'minotni ishlab chiqish sohasida alohida komponentlarning izolyatsiyada to'g'ri ishlashini ta'minlash (moduliy testlash) juda muhim. Biroq, bu komponentlarning birgalikda uzluksiz ishlashini tekshirish ham xuddi shunday muhimdir. Aynan shu yerda integratsion testlash o'z o'rnini egallaydi. Integratsion testlash ilova ichidagi turli modullar yoki xizmatlar o'rtasidagi o'zaro ta'sirni tasdiqlashga qaratilgan. Ushbu maqolada integratsion testlash chuqur o'rganiladi, xususan, Node.js'dagi HTTP tasdiqlarini sinash uchun mo'ljallangan kuchli va qulay kutubxona bo'lgan Supertest yordamida API testlashga e'tibor qaratiladi.

Integratsion Testlash nima?

Integratsion testlash - bu alohida dasturiy modullarni birlashtirib, ularni guruh sifatida sinovdan o'tkazadigan dasturiy ta'minotni sinash turidir. Uning maqsadi birlashtirilgan birliklar o'rtasidagi o'zaro ta'sirlardagi nuqsonlarni aniqlashdir. Alohida komponentlarga e'tibor qaratadigan moduliy testlashdan farqli o'laroq, integratsion testlash modullar o'rtasidagi ma'lumotlar oqimi va boshqaruv oqimini tekshiradi. Keng tarqalgan integratsion testlash yondashuvlariga quyidagilar kiradi:

• Yuqoridan pastga integratsiya: Eng yuqori darajadagi modullardan boshlab, pastga qarab integratsiyalash.
• Pastdan yuqoriga integratsiya: Eng quyi darajadagi modullardan boshlab, yuqoriga qarab integratsiyalash.
• "Katta portlash" integratsiyasi: Barcha modullarni bir vaqtda integratsiyalash. Muammolarni izolyatsiya qilish qiyinligi sababli, bu yondashuv odatda tavsiya etilmaydi.
• "Sendvich" integratsiyasi: Yuqoridan pastga va pastdan yuqoriga integratsiyaning kombinatsiyasi.

APIlar kontekstida integratsion testlash turli API'larning birgalikda to'g'ri ishlashini, ular o'rtasida uzatiladigan ma'lumotlarning izchilligini va umumiy tizimning kutilganidek ishlashini tekshirishni o'z ichiga oladi. Masalan, mahsulotlarni boshqarish, foydalanuvchi autentifikatsiyasi va to'lovlarni qayta ishlash uchun alohida API'larga ega bo'lgan elektron tijorat ilovasini tasavvur qiling. Integratsion testlash ushbu API'larning to'g'ri aloqa qilishini ta'minlab, foydalanuvchilarga mahsulotlarni ko'rib chiqish, xavfsiz tizimga kirish va xaridlarni yakunlash imkonini beradi.

Nima uchun API Integratsion Testlash muhim?

API integratsion testlash bir necha sabablarga ko'ra juda muhim:

• Tizim ishonchliligini ta'minlaydi: Bu ishlab chiqish siklining dastlabki bosqichlarida integratsiya muammolarini aniqlashga yordam beradi, bu esa ishlab chiqarishdagi kutilmagan nosozliklarning oldini oladi.
• Ma'lumotlar yaxlitligini tasdiqlaydi: Bu ma'lumotlarning turli API'lar o'rtasida to'g'ri uzatilishi va o'zgartirilishini tekshiradi.
• Ilovaning ishlash samaradorligini oshiradi: U API o'zaro ta'sirlari bilan bog'liq ishlashdagi zaif nuqtalarni aniqlashi mumkin.
• Xavfsizlikni kuchaytiradi: U noto'g'ri API integratsiyasidan kelib chiqadigan xavfsizlik zaifliklarini aniqlashi mumkin. Masalan, API'lar o'zaro aloqada bo'lganda to'g'ri autentifikatsiya va avtorizatsiyani ta'minlash.
• Ishlab chiqish xarajatlarini kamaytiradi: Integratsiya muammolarini erta tuzatish, ularni ishlab chiqish hayotiy siklining keyingi bosqichlarida hal qilishdan ancha arzonroq.

Global sayohatlarni bron qilish platformasini ko'rib chiqing. API integratsion testlash turli mamlakatlardan kelgan parvozlarni bron qilish, mehmonxonalarni band qilish va to'lov shlyuzlarini boshqaradigan API'lar o'rtasida uzluksiz aloqani ta'minlash uchun juda muhimdir. Ushbu API'larni to'g'ri integratsiya qilmaslik noto'g'ri bron qilishlarga, to'lovlardagi nosozliklarga va yomon foydalanuvchi tajribasiga olib kelishi mumkin, bu esa platformaning obro'si va daromadiga salbiy ta'sir qiladi.

Supertest bilan tanishuv: API Testlash uchun kuchli vosita

Supertest - bu HTTP so'rovlarini sinash uchun yuqori darajadagi abstraktsiya. U ilovangizga so'rovlar yuborish va javoblarni tasdiqlash uchun qulay va ravon API taqdim etadi. Node.js ustiga qurilgan Supertest, ayniqsa Node.js HTTP serverlarini sinash uchun mo'ljallangan. U Jest va Mocha kabi mashhur testlash freymvorklari bilan a'lo darajada ishlaydi.

Supertest'ning asosiy xususiyatlari:

• Foydalanish oson: Supertest HTTP so'rovlarini yuborish va tasdiqlash uchun oddiy va intuitiv API taklif qiladi.
• Asinxron testlash: U asinxron operatsiyalarni muammosiz boshqaradi, bu esa uni asinxron mantiqqa tayanadigan API'larni sinash uchun ideal qiladi.
• Ravon interfeys: U ravon interfeysni taqdim etadi, bu esa qisqa va o'qilishi oson testlar uchun metodlarni zanjirband qilish imkonini beradi.
• Keng qamrovli tasdiqlashni qo'llab-quvvatlash: U javob holati kodlari, sarlavhalari va tanasini tekshirish uchun keng ko'lamli tasdiqlashlarni qo'llab-quvvatlaydi.
• Testlash freymvorklari bilan integratsiya: U Jest va Mocha kabi mashhur testlash freymvorklari bilan muammosiz integratsiyalashadi, bu sizga mavjud testlash infratuzilmangizdan foydalanish imkonini beradi.

Testlash Muhitini Sozlash

Boshlashdan oldin, asosiy testlash muhitini sozlab olaylik. Sizda Node.js va npm (yoki yarn) o'rnatilgan deb taxmin qilamiz. Biz testlash freymvorki sifatida Jest'dan va API testlash uchun Supertest'dan foydalanamiz.

1. Node.js loyihasini yarating:

            mkdir api-testing-example
cd api-testing-example
npm init -y
            

              
                Copy
              
            
          

2. Bog'liqliklarni o'rnating:

            npm install --save-dev jest supertest
npm install express  # Yoki API yaratish uchun siz afzal ko'rgan freymvork
            

              
                Copy
              
            
          

3. Jest'ni sozlang: package.json faylingizga quyidagilarni qo'shing:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. Oddiy API endpoint'ini yarating: Loyihangizda app.js (yoki shunga o'xshash) nomli fayl yarating va unga quyidagi kodni kiriting:

            const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Testlash uchun eksport qilish

            

              
                Copy
              
            
          

Birinchi Supertest Testini Yozish

Endi muhitimiz sozlangandan so'ng, API endpoint'imizni tekshirish uchun oddiy Supertest testini yozamiz. Loyihangizning ildiz papkasida app.test.js (yoki shunga o'xshash) nomli fayl yarating:

            const request = require('supertest');
const app = require('./app');

descibe('GET /hello', () => {
  it('200 OK bilan javob beradi va "Hello, World!" matnini qaytaradi', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

            

              
                Copy
              
            
          

Tushuntirish:

• Biz supertest va Express ilovamizni import qilamiz.
• Testlarimizni guruhlash uchun describe'dan foydalanamiz.
• Muayyan bir test holatini aniqlash uchun it'dan foydalanamiz.
• Ilovamizga so'rovlar yuboradigan Supertest agentini yaratish uchun request(app)'dan foydalanamiz.
• /hello endpoint'iga GET so'rovini yuborish uchun .get('/hello')'dan foydalanamiz.
• Javobni kutish uchun await'dan foydalanamiz. Supertest metodlari promiselarni qaytaradi, bu esa bizga toza kod uchun async/await'dan foydalanish imkonini beradi.
• Javob holati kodi 200 OK ekanligini tasdiqlash uchun expect(response.statusCode).toBe(200)'dan foydalanamiz.
• Javob tanasi "Hello, World!" ekanligini tasdiqlash uchun expect(response.text).toBe('Hello, World!')'dan foydalanamiz.

Testni ishga tushirish uchun terminalingizda quyidagi buyruqni bajaring:

            npm test
            

              
                Copy
              
            
          

Agar hamma narsa to'g'ri sozlangan bo'lsa, testning muvaffaqiyatli o'tganini ko'rishingiz kerak.

Supertest'ning Ilg'or Usullari

Supertest ilg'or API testlash uchun keng ko'lamli xususiyatlarni taklif etadi. Keling, ulardan ba'zilarini ko'rib chiqaylik.

1. So'rov tanasini yuborish

So'rov tanasida ma'lumotlar yuborish uchun .send() metodidan foydalanishingiz mumkin. Masalan, JSON ma'lumotlarini qabul qiladigan endpoint yarataylik:

            app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Ma'lumotlar bazasida foydalanuvchi yaratishni simulyatsiya qilish
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});
            

              
                Copy
              
            
          

Ushbu endpoint'ni Supertest yordamida quyidagicha sinab ko'rishingiz mumkin:

            describe('POST /users', () => {
  it('yangi foydalanuvchi yaratadi', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});
            

              
                Copy
              
            
          

Tushuntirish:

• /users endpoint'iga POST so'rovini yuborish uchun .post('/users')'dan foydalanamiz.
• So'rov tanasida userData obyektini yuborish uchun .send(userData)'dan foydalanamiz. Supertest avtomatik ravishda Content-Type sarlavhasini application/json qilib o'rnatadi.
• Javob holati kodi 201 Created ekanligini tasdiqlash uchun .expect(201)'dan foydalanamiz.
• Javob tanasida id xususiyati mavjudligini tasdiqlash uchun expect(response.body).toHaveProperty('id')'dan foydalanamiz.
• Javob tanasidagi name va email xususiyatlari biz so'rovda yuborgan ma'lumotlarga mos kelishini tasdiqlash uchun expect(response.body.name).toBe(userData.name) va expect(response.body.email).toBe(userData.email)'dan foydalanamiz.

2. Sarlavhalarni o'rnatish

So'rovlaringizda maxsus sarlavhalarni o'rnatish uchun .set() metodidan foydalanishingiz mumkin. Bu autentifikatsiya tokenlarini, kontent turlarini yoki boshqa maxsus sarlavhalarni o'rnatish uchun foydalidir.

            describe('GET /protected', () => {
  it('autentifikatsiyani talab qiladi', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('yaroqli token bilan 200 OK qaytaradi', async () => {
    // Yaroqli token olishni simulyatsiya qilish
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});
            

              
                Copy
              
            
          

Tushuntirish:

• Authorization sarlavhasini Bearer ${token} qilib o'rnatish uchun .set('Authorization', `Bearer ${token}`)'dan foydalanamiz.

3. Cookie'lar bilan ishlash

Supertest cookie'lar bilan ham ishlay oladi. Cookie'larni .set('Cookie', ...) metodi yordamida o'rnatishingiz mumkin yoki cookie'larga kirish va ularni o'zgartirish uchun .cookies xususiyatidan foydalanishingiz mumkin.

4. Fayl yuklashni testlash

Supertest fayl yuklashni boshqaradigan API endpoint'larini sinash uchun ishlatilishi mumkin. Fayllarni so'rovga biriktirish uchun .attach() metodidan foydalanishingiz mumkin.

5. Tasdiqlash kutubxonalaridan foydalanish (Chai)

Jest'ning o'rnatilgan tasdiqlash kutubxonasi ko'p hollarda yetarli bo'lsa-da, siz Supertest bilan Chai kabi kuchliroq tasdiqlash kutubxonalaridan ham foydalanishingiz mumkin. Chai yanada ifodali va moslashuvchan tasdiqlash sintaksisini taqdim etadi. Chai'dan foydalanish uchun uni o'rnatishingiz kerak bo'ladi:

            npm install --save-dev chai
            

              
                Copy
              
            
          

Keyin, Chai'ni test faylingizga import qilib, uning tasdiqlaridan foydalanishingiz mumkin:

            const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('200 OK bilan javob beradi va "Hello, World!" matnini qaytaradi', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});
            

              
                Copy
              
            
          

Eslatma: Chai bilan to'g'ri ishlash uchun Jest'ni sozlash kerak bo'lishi mumkin. Bu ko'pincha Chai'ni import qiladigan va uni Jest'ning global expect'i bilan ishlash uchun sozlaydigan sozlash faylini qo'shishni o'z ichiga oladi.

6. Agentlardan qayta foydalanish

Maxsus muhitni (masalan, autentifikatsiya) sozlashni talab qiladigan testlar uchun Supertest agentidan qayta foydalanish ko'pincha foydalidir. Bu har bir test holatida ortiqcha sozlash kodidan qochishga yordam beradi.

            describe('Autentifikatsiyalangan API Testlari', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Doimiy agent yaratish
    // Autentifikatsiyani simulyatsiya qilish
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('himoyalangan resursga kira oladi', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('autentifikatsiyani talab qiladigan boshqa amallarni bajara oladi', async () => {
    // Boshqa autentifikatsiyalangan amallarni shu yerda bajaring
  });
});
            

              
                Copy
              
            
          

Ushbu misolda biz beforeAll hook'ida Supertest agentini yaratamiz va agentni autentifikatsiya qilamiz. Keyinchalik describe bloki ichidagi testlar har bir test uchun qayta autentifikatsiya qilmasdan ushbu autentifikatsiyalangan agentdan qayta foydalanishi mumkin.

Supertest bilan API Integratsion Testlash uchun Eng Yaxshi Amaliyotlar

Samarali API integratsion testlashni ta'minlash uchun quyidagi eng yaxshi amaliyotlarni ko'rib chiqing:

• Uchdan-uchgacha bo'lgan ish oqimlarini sinab ko'ring: Izolyatsiya qilingan API endpoint'lariga emas, balki to'liq foydalanuvchi ish oqimlarini sinashga e'tibor qarating. Bu alohida API'larni sinashda ko'rinmaydigan integratsiya muammolarini aniqlashga yordam beradi.
• Realistik ma'lumotlardan foydalaning: Haqiqiy dunyo stsenariylarini simulyatsiya qilish uchun testlaringizda realistik ma'lumotlardan foydalaning. Bu to'g'ri ma'lumot formatlari, chegara qiymatlari va xatoliklarni qayta ishlashni sinash uchun potentsial yaroqsiz ma'lumotlardan foydalanishni o'z ichiga oladi.
• Testlaringizni izolyatsiya qiling: Testlaringizning bir-biridan mustaqil ekanligiga va ular umumiy holatga tayanmasligiga ishonch hosil qiling. Bu sizning testlaringizni yanada ishonchli va disk raskadrovka qilishni osonlashtiradi. Maxsus test ma'lumotlar bazasidan foydalanishni yoki tashqi bog'liqliklarni mock qilishni ko'rib chiqing.
• Tashqi bog'liqliklarni mock qiling: API'ngizni ma'lumotlar bazalari, uchinchi tomon API'lari yoki boshqa xizmatlar kabi tashqi bog'liqliklardan izolyatsiya qilish uchun mock'lardan foydalaning. Bu sizning testlaringizni tezroq va ishonchliroq qiladi, shuningdek, tashqi xizmatlarning mavjudligiga tayanmasdan turli stsenariylarni sinash imkonini beradi. nock kabi kutubxonalar HTTP so'rovlarini mock qilish uchun foydalidir.
• Keng qamrovli testlar yozing: Ijobiy testlar (muvaffaqiyatli javoblarni tekshirish), salbiy testlar (xatoliklarni qayta ishlashni tekshirish) va chegara testlari (chekka holatlarni tekshirish) kabi keng qamrovli test qamroviga intiling.
• Testlaringizni avtomatlashtiring: API integratsion testlaringizni uzluksiz integratsiya (CI) quvuringizga integratsiya qiling, ular kod bazasiga o'zgartirishlar kiritilganda avtomatik ravishda ishga tushishini ta'minlang. Bu integratsiya muammolarini erta aniqlashga va ularning ishlab chiqarishga yetib borishini oldini olishga yordam beradi.
• Testlaringizni hujjatlashtiring: API integratsion testlaringizni aniq va qisqa hujjatlashtiring. Bu boshqa ishlab chiquvchilarga testlarning maqsadini tushunishni va ularni vaqt o'tishi bilan saqlab turishni osonlashtiradi.
• Muhit o'zgaruvchilaridan foydalaning: API kalitlari, ma'lumotlar bazasi parollari va boshqa konfiguratsiya qiymatlari kabi maxfiy ma'lumotlarni testlaringizda qattiq kodlash o'rniga muhit o'zgaruvchilarida saqlang. Bu sizning testlaringizni xavfsizroq va turli muhitlar uchun sozlashni osonlashtiradi.
• API shartnomalarini ko'rib chiqing: API'ngiz belgilangan shartnomaga (masalan, OpenAPI/Swagger) rioya qilishini tasdiqlash uchun API shartnoma testidan foydalaning. Bu turli xizmatlar o'rtasidagi moslikni ta'minlashga yordam beradi va buzuvchi o'zgarishlarning oldini oladi. Pact kabi vositalar shartnoma testi uchun ishlatilishi mumkin.

Qochish kerak bo'lgan umumiy xatolar

• Testlarni izolyatsiya qilmaslik: Testlar mustaqil bo'lishi kerak. Boshqa testlarning natijasiga tayanmang.
• Amalga oshirish tafsilotlarini sinash: API'ning ichki amalga oshirilishiga emas, balki uning xulq-atvori va shartnomasiga e'tibor qarating.
• Xatoliklarni qayta ishlashni e'tiborsiz qoldirish: API'ngiz noto'g'ri kiritishlar, chekka holatlar va kutilmagan xatolarni qanday boshqarishini sinchkovlik bilan sinab ko'ring.
• Autentifikatsiya va avtorizatsiya testlarini o'tkazib yuborish: Ruxsatsiz kirishni oldini olish uchun API'ngizning xavfsizlik mexanizmlari to'g'ri sinovdan o'tganligiga ishonch hosil qiling.

Xulosa

API integratsion testlash dasturiy ta'minotni ishlab chiqish jarayonining muhim qismidir. Supertest yordamida siz ilovangizning sifati va barqarorligini ta'minlashga yordam beradigan keng qamrovli va ishonchli API integratsion testlarini osongina yozishingiz mumkin. Uchdan-uchgacha bo'lgan ish oqimlarini sinashga, realistik ma'lumotlardan foydalanishga, testlaringizni izolyatsiya qilishga va testlash jarayonini avtomatlashtirishga e'tibor qaratishni unutmang. Ushbu eng yaxshi amaliyotlarga rioya qilish orqali siz integratsiya muammolari xavfini sezilarli darajada kamaytirishingiz va yanada mustahkam va ishonchli mahsulot taqdim etishingiz mumkin.

API'lar zamonaviy ilovalar va mikroxizmatlar arxitekturalarini boshqarishda davom etar ekan, mustahkam API testlashning, ayniqsa integratsion testlashning ahamiyati faqat o'sib boradi. Supertest butun dunyodagi ishlab chiquvchilar uchun API o'zaro ta'sirlarining ishonchliligi va sifatini ta'minlash uchun kuchli va qulay vositalar to'plamini taqdim etadi.